﻿//using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text;
//using System.Diagnostics;
//using GenericLibrary.Modeling;
//using GenericLibrary.Modeling.DynamicAgent;

//namespace GenericLibrary.Modeling.SpikingNeuralNetwork {

//    /// <summary>
//    /// 神经元基类，继承动态代理类
//    /// 神经元的行为导致整个神经网络的位势在不同时空的波动
//    /// 此神经元模型对经典模型进行了简化：神经元的静息位势（Resting Potential == 0）发放阈值（Firing Threshold == 1）以及发放后位势（After Firing Potential == -1）作归一化处理。这样整个网络以突触的强度（Synaptic Strength）和延迟（Synaptic Delay）为参数
//    /// </summary>
//    public abstract class Neuron : IDynamicAgent {

//        /// <summary>
//        /// 神经元的位势，静息位势为0
//        /// </summary>
//        private double _potential;

//        /// <summary>
//        /// 发放前神经元位势复位常数，(-1,0)
//        /// </summary>
//        private double _preFiringResetingConstant;

//        /// <summary>
//        /// 发放后神经元位势复位常数，(-1,0)
//        /// </summary>
//        private double _postFiringResetingConstant;

//        /// <summary>
//        /// 神经元所连接的传出突触，决定神经网络的拓扑结构
//        /// </summary>
//        protected abstract IEnumerable<Synapse> OutputSynapses { get; }

//        /// <summary>
//        /// 神经元输入
//        /// </summary>
//        /// <param name="postSynapticPotential">
//        /// 传入的突出后电位(-1,1)，如果传入突触为激励型突触，值为正，如果是抑制型突触，值为负
//        /// </param>
//        public void Input( double postSynapticPotential ) {
//            this._potential += postSynapticPotential;
//        }

//        protected Neuron( double preFiringResettingConstant, double postFiringResettingConstant ) {
//            try {
//                if( ( preFiringResettingConstant > -1 && preFiringResettingConstant < 0 ) && ( postFiringResettingConstant > -1 && postFiringResettingConstant < 0 ) ) {
//                    this._potential = 0;
//                    this._preFiringResetingConstant = preFiringResettingConstant;
//                    this._postFiringResetingConstant = postFiringResettingConstant;
//                } else {
//                    throw new Exception();
//                }
//            } catch( Exception ) {
//                Debug.Assert( false );
//                throw;
//            }
//        }

//        #region IDynamicAgent Members

//        /// <summary>
//        /// 时间同步，对神经元位势按时间步长复位
//        /// </summary>
//        /// <param name="timeStep"></param>
//        void IDynamicAgent.Synchronize( double timeStep ) {
//            try {
//                if( this._potential > 0 ) {
//                    this._potential = Math.Exp( Math.Log( this._potential, Math.E ) + timeStep * this._preFiringResetingConstant );
//                } else if( this._potential < 0 ) {
//                    this._potential = -Math.Exp( Math.Log( -this._potential, Math.E ) + timeStep * this._postFiringResetingConstant );
//                }
//            } catch( Exception ) {
//                Debug.Assert( false );
//                throw;
//            }
//        }

//        /// <summary>
//        /// 神经元输出方法，输出后神经元的位势设为发放后位势-1
//        /// </summary>
//        void IDynamicAgent.Output() {
//            try {
//                foreach( Synapse synapse in this.OutputSynapses ) {
//                    synapse.Input();
//                }
//                this._potential = -1;
//            } catch( Exception ) {
//                Debug.Assert( false );
//                throw;
//            }
//        }

//        /// <summary>
//        /// 神经元发放延时，如果当前位势大于等于发放阈值1，延时值为0，如果当前位势小于1延时值为正无穷
//        /// </summary>
//        double IDynamicAgent.OutputDelay {
//            get {
//                try {
//                    if( this._potential >= 1 ) {
//                        return 0;
//                    } else {
//                        return double.PositiveInfinity;
//                    }
//                } catch( Exception ) {
//                    Debug.Assert( false );
//                    throw;
//                }
//            }
//        }

//        #endregion
//    }

//    //Synapse as a delay-output unit
//    //for practical consideration, the unit do not buffer inputs which means the transmission delay charaterises the synapse should be far smaller than the neuron refractory period.
//    public abstract class Synapse : IDynamicAgent {

//        private double _outputDelay;

//        /// <summary>
//        /// 突触强度常数
//        /// </summary>
//        private double _strengthConstant;

//        /// <summary>
//        /// 突触延迟常数
//        /// </summary>
//        private double _delayConstant;

//        protected abstract Neuron OutputNeuron { get; }

//        internal void Input() {
//            try {
//                if( double.IsPositiveInfinity( this._outputDelay ) ) {//pre-synaptic input is invalid if previous firing not completed!
//                    this._outputDelay = this.Inductance;
//                } else {
//                    throw new Exception();
//                }
//            } catch( Exception ) {
//                Debug.Assert( false );
//                throw;
//            }
//        }

//        protected Synapse() {
//            this._outputDelay = double.PositiveInfinity;
//        }

//        #region IDynamicAgent Members

//        void IDynamicAgent.Synchronize( double timeStep ) {
//            this._outputDelay -= timeStep;//timeStep<outputDelay
//        }

//        void IDynamicAgent.Output() {
//            try {
//                this.OutputNeuron.Input( this.Impedance );
//                this._outputDelay = double.PositiveInfinity;
//            } catch( Exception ) {
//                Debug.Assert( false );
//                throw;
//            }
//        }

//        double IDynamicAgent.OutputDelay {
//            get { return this._outputDelay; }
//        }

//        #endregion
//    }

//    /// <summary>
//    /// 兴奋性突触
//    /// </summary>
//    public abstract class ExcitatorySynapse : Synapse {

//    }

//    /// <summary>
//    /// 抑制性突触
//    /// </summary>
//    public abstract class InhibitorySynapse : Synapse {

//    }





//}
